package com.libl.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.util.Arrays;

/**
 * @Aspect: 标记该类为切面类
 * @Pointcut： 配置切入点表达式 标记在方法上（方法不需要参数和返回值）
 * @Around： 环绕增强
 * @Before： 前置增强
 * @AfterReturning： 后置增强
 * @AfterThrowing： 异常增强
 * @After： 最终增强
 */

@Component
@Aspect
public class AspectTest {
    @Pointcut("execution(* com.libl.service..*.*(..))")
    public void pc(){

    }

    @Around("pc()")
    public Object around(ProceedingJoinPoint proceedingJoinPoint){
        try {
            System.out.println("前置增强");
            //执行原始方法，返回值是原始方法的返回值
            Object result = proceedingJoinPoint.proceed();
            System.out.println("后置增强(有异常则不执行)");
            return result;

        } catch (Throwable throwable) {
            throwable.printStackTrace();
            System.out.println("异常增强");
        } finally {
            System.out.println("最终增强");
        }
        return null;
    }

    /**
     * joinPoint:连接点对象（对方法的描述），一般用在前置增强上
     * 要想拿到原始方法的返回值得用环绕增强才行
     * ProceedingJoinPoint:连接点对象，可以调用原始方法拿到返回值
     */


    /*@Before("pc()")
    public void before(JoinPoint joinPoint){

        //获取执行的类
        Class<?> clazz = joinPoint.getTarget().getClass();
        System.out.println(clazz);
        //获取执行的方法名
        String name = joinPoint.getSignature().getName();
        System.out.println(name);
        //获取参数列表
        Object[] args = joinPoint.getArgs();
        System.out.println(Arrays.toString(args));

        System.out.println("前置增强");
    }
    @AfterReturning("pc()")
    public void afterReturning(){
            System.out.println("后置增强(有异常则不执行)");
        }
    @AfterThrowing("pc()")
    public void afterThrowing(){
            System.out.println("异常增强");
        }
    @After("pc()")
    public void after(){
            System.out.println("最终增强");
        }*/

}
